home *** CD-ROM | disk | FTP | other *** search
/ ETO Development Tools 1 / ETO Development Tools 1.iso / Tools - Objects / MacApp / Unsupported Samples / CRC Cards / Source / UTextHandler.inc1.p < prev    next >
Encoding:
Text File  |  1990-07-11  |  25.7 KB  |  909 lines  |  [TEXT/MPS ]
  1.     {---------- Methods for TTextHandler ----------}
  2.  
  3.     {$S ATextHandler}
  4.     FUNCTION TTextHandler.GetDesignDocument: TDesignDocument;
  5.         BEGIN
  6.             GetDesignDocument:= fDesignDocument;
  7.         END;    {TTextHandler.GetDesignDocument}
  8.         
  9.     {$S ATextHandler}
  10.     PROCEDURE TTextHandler.SetDesignDocument(theDesignDoc: TDesignDocument);
  11.     
  12.         BEGIN
  13.             fDesignDocument:= theDesignDoc;
  14.         END;    {TTextHandler.SetDesignDocument}
  15.  
  16.     {$S ATextHandler}
  17.     FUNCTION TTextHandler.GetLanguage:Integer;
  18.         BEGIN
  19.             GetLanguage:= fLanguage;
  20.         END;    {TTextHandler.GetLanguage}
  21.  
  22.     {$S ATextHandler}
  23.     PROCEDURE TTextHandler.SetLanguage(theLanguage:    Integer);
  24.         BEGIN
  25.             fLanguage:= theLanguage;
  26.         END;    {TTextHandler.SetLanguage}
  27.  
  28.     {$S ATextHandler}
  29.     PROCEDURE TTextHandler.ITTextHandler(theDesignDoc: TDesignDocument);
  30.     
  31.         BEGIN
  32.             SELF.SetDesignDocument(theDesignDoc);
  33.             SELF.SetLanguage(kInPascal);
  34.             SELF.ReadInTypeTable;
  35.         END;    {TTextHandler.ITTextHandler}
  36.  
  37.     {$S ATextHandler}
  38.     PROCEDURE TTextHandler.Replace(VAR origString: str255; pattern, replacement: str255);
  39.     
  40.         VAR
  41.             theIndex,
  42.             theLength: INTEGER;
  43.     
  44.         BEGIN
  45.             theIndex:= Pos(pattern, origString);
  46.             theLength:= Length(pattern);
  47.             WHILE theIndex <> 0 DO
  48.                 BEGIN
  49.                     Delete(origString, theIndex, theLength);
  50.                     Insert(replacement, origString, theIndex);
  51.                     theIndex:= Pos(pattern, origString);
  52.                 END;
  53.         END;    {TTextHandler.Replace}
  54.  
  55.     {$S ATextHandler}
  56.     FUNCTION TTextHandler.GetAndEntabRsrcString(itsResourceID:Integer):Str255;
  57.         VAR
  58.             aStringHandle: StringHandle;
  59.             aString : Str255;
  60.  
  61.         BEGIN
  62.             IF SELF.GetLanguage = kInCPP THEN itsResourceID := itsResourceID + 1000;
  63.             aStringHandle:= GetString(itsResourceID);
  64.             FailResError;
  65.             aString:=aStringHandle^^;
  66.             SELF.Replace(aString, '^TAB', gOneTabStr);
  67.             GetAndEntabRsrcString:= aString;
  68.         END;
  69.  
  70.     {$S ATextHandler}
  71.     FUNCTION TTextHandler.GetTypeDefStr(theCard:TCard):Str255;
  72.         VAR
  73.           aClassItem, aSuperClassItem : TItem;
  74.           aString : Str255; 
  75.           
  76.         BEGIN
  77.           aClassItem:= theCard.GetTheClass;
  78.           aSuperClassItem:= theCard.GetTheSuperClass;
  79.           aString:= GetAndEntabRsrcString(kTypeDefID);
  80.           SELF.Replace(aString, '^0', aClassItem.GetTheName);
  81.           SELF.Replace(aString, '^1', aSuperClassItem.GetTheName);
  82.           GetTypeDefStr:=aString;
  83.         END;
  84.  
  85.     {$S ATextHandler}
  86.     FUNCTION TTextHandler.GetHeadingStr:Str255;
  87.         VAR
  88.           theTitle, aString : Str255; 
  89.           
  90.         BEGIN
  91.             aString:= GetAndEntabRsrcString(kHeadingID);
  92.             theTitle:= fDesignDocument.GetUnitName;
  93.             SELF.CheckFileName(theTitle);
  94.             (*SLIMEY MUCK*)
  95.             SELF.Replace(aString, '^0', theTitle);
  96.             GetHeadingStr:=aString;
  97.         END;
  98.         
  99.     {$S ATextHandler}
  100.     FUNCTION TTextHandler.GetFieldsInterfaceStr:Str255;
  101.           
  102.         BEGIN
  103.             GetFieldsInterfaceStr:= GetAndEntabRsrcString(kFieldsInterfaceID);
  104.         END;
  105.  
  106.     {$S ATextHandler}
  107.     FUNCTION TTextHandler.GetMethodsInterfaceStr:Str255;
  108.  
  109.         BEGIN
  110.             GetMethodsInterfaceStr:= GetAndEntabRsrcString(kMethodsInterfaceID);
  111.         END;
  112.  
  113.     {$S ATextHandler}
  114.     FUNCTION TTextHandler.GetCollaboratorsInterfaceStr:Str255;
  115.  
  116.         BEGIN
  117.             GetCollaboratorsInterfaceStr:= GetAndEntabRsrcString(kCollaboratorsInterfaceID);
  118.         END;
  119.  
  120.     {$S ATextHandler}
  121.     FUNCTION TTextHandler.GetEndOfTypeDefStr:Str255;
  122.           
  123.         BEGIN
  124.             GetEndOfTypeDefStr:= GetAndEntabRsrcString(kEndOfTypeDefID);
  125.         END;
  126.  
  127.     {$S ATextHandler}
  128.     FUNCTION TTextHandler.GetStdMethStr(TheMethodItem:TMethodItem):Str255;
  129.         VAR
  130.             theCard: TCard;
  131.             theClass: TItem;
  132.             theClassName: str255;
  133.             aString: str255;
  134.           
  135.         BEGIN
  136.             theCard:= TheMethodItem.GetTheCard;
  137.             theClass:= theCard.GetTheClass;
  138.             theClassName:= theClass.GetTheItem;
  139.             aString:= GetAndEntabRsrcString(kStdMethID);
  140.             SELF.Replace(aString, '^0', theClassName);
  141.             SELF.Replace(aString, '^1', TheMethodItem.GetTheItem);
  142.             GetStdMethStr:=aString;
  143.         END;
  144.  
  145.     {$S ATextHandler}
  146.     FUNCTION TTextHandler.GetOverrideMethStr(TheMethodItem:TMethodItem):Str255;
  147.         VAR
  148.             theCard: TCard;
  149.             theClass: TItem;
  150.             theClassName: str255;
  151.             aString: str255;
  152.           
  153.         BEGIN
  154.             theCard:= TheMethodItem.GetTheCard;
  155.             theClass:= theCard.GetTheClass;
  156.             theClassName:= theClass.GetTheItem;
  157.             aString:= GetAndEntabRsrcString(kOverrideMethID);
  158.             SELF.Replace(aString, '^0', theClassName);
  159.             SELF.Replace(aString, '^1', TheMethodItem.GetTheItem);
  160.             GetOverrideMethStr:=aString
  161.         END;
  162.  
  163.     {$S ATextHandler}
  164.     FUNCTION TTextHandler.GetStdImplMethStr(TheMethodItem:TMethodItem):Str255;
  165.         VAR
  166.             theCard: TCard;
  167.             theClass: TItem;
  168.             theClassName: str255;
  169.             aString: str255;
  170.           
  171.         BEGIN
  172.             theCard:= TheMethodItem.GetTheCard;
  173.             theClass:= theCard.GetTheClass;
  174.             theClassName:= theClass.GetTheItem;
  175.             aString:= GetAndEntabRsrcString(kStdImplMethID);
  176.             SELF.Replace(aString, '^0', theClassName);
  177.             SELF.Replace(aString, '^1', TheMethodItem.GetTheItem);
  178.             GetStdImplMethStr:=aString;
  179.         END;
  180.  
  181.     {$S ATextHandler}
  182.     FUNCTION TTextHandler.GetOverrideImplMethStr(TheMethodItem:TMethodItem):Str255;
  183.         VAR
  184.             theCard: TCard;
  185.             theClass: TItem;
  186.             theClassName: str255;
  187.             aString: str255;
  188.           
  189.         BEGIN
  190.             theCard:= TheMethodItem.GetTheCard;
  191.             theClass:= theCard.GetTheClass;
  192.             theClassName:= theClass.GetTheItem;
  193.             aString:= GetAndEntabRsrcString(kOverrideImplMethID);
  194.             SELF.Replace(aString, '^0', theClassName);
  195.             SELF.Replace(aString, '^1', TheMethodItem.GetTheItem);
  196.             GetOverrideImplMethStr:=aString
  197.         END;
  198.  
  199.     {$S ATextHandler}
  200.     FUNCTION TTextHandler.GetGetAccessorStr(TheAccessorItem:TAccessorItem):Str255;
  201.         VAR
  202.             theCard: TCard;
  203.           aString : Str255; 
  204.             theClass: TItem;
  205.           
  206.         BEGIN
  207.             theCard:= TheAccessorItem.GetTheCard;
  208.             theClass:= theCard.GetTheClass;
  209.             aString:= GetAndEntabRsrcString(kGetAccessorID);
  210.             SELF.Replace(aString, '^0', theClass.GetTheItem);
  211.             SELF.Replace(aString, '^1', TheAccessorItem.GetTheItem);
  212.             SELF.Replace(aString, '^2', TheAccessorItem.GetFieldAccessed.GetItemType);
  213.             IF TheAccessorItem.fFieldAccessed.GetPassByAddress THEN
  214.                 SELF.Replace(aString, '^4', '*')
  215.             ELSE
  216.                 SELF.Replace(aString, '^4', kEmptyString);
  217.             GetGetAccessorStr:=aString;
  218.         END;
  219.  
  220.     {$S ATextHandler}
  221.     FUNCTION TTextHandler.GetSetAccessorStr(TheAccessorItem:TAccessorItem):Str255;
  222.         VAR
  223.             theCard: TCard;
  224.           aString : Str255; 
  225.             theClass: TItem;
  226.           
  227.         BEGIN
  228.             theCard:= TheAccessorItem.GetTheCard;
  229.             theClass:= theCard.GetTheClass;
  230.             aString:= GetAndEntabRsrcString(kSetAccessorID);
  231.             SELF.Replace(aString, '^0', theClass.GetTheItem);
  232.             SELF.Replace(aString, '^1', TheAccessorItem.GetTheItem);
  233.             SELF.Replace(aString, '^2', TheAccessorItem.GetFieldAccessed.GetItemType);
  234.             SELF.Replace(aString, '^3', TheAccessorItem.GetParameter);
  235.             IF TheAccessorItem.fFieldAccessed.GetPassByAddress THEN
  236.                 SELF.Replace(aString, '^4', '*')
  237.             ELSE
  238.                 SELF.Replace(aString, '^4', kEmptyString);
  239.             GetSetAccessorStr:=aString;
  240.         END;
  241.  
  242.     {$S ATextHandler}
  243.     FUNCTION TTextHandler.GetImplGetAccessorStr(TheAccessorItem:TAccessorItem):Str255;
  244.         VAR
  245.             theCard: TCard;
  246.           aString : Str255; 
  247.             theClass: TItem;
  248.           
  249.         BEGIN
  250.             theCard:= TheAccessorItem.GetTheCard;
  251.             theClass:= theCard.GetTheClass;
  252.             aString:= GetAndEntabRsrcString(kImplGetAccessorID);
  253.             SELF.Replace(aString, '^0', theClass.GetTheItem);
  254.             SELF.Replace(aString, '^1', TheAccessorItem.GetTheItem);
  255.             SELF.Replace(aString, '^2', TheAccessorItem.GetFieldAccessed.GetItemType);
  256.             IF TheAccessorItem.fFieldAccessed.GetPassByAddress THEN
  257.                 SELF.Replace(aString, '^4', '*')
  258.             ELSE
  259.                 SELF.Replace(aString, '^4', kEmptyString);
  260.             GetImplGetAccessorStr:=aString;
  261.         END;
  262.  
  263.     {$S ATextHandler}
  264.     FUNCTION TTextHandler.GetImplSetAccessorStr(TheAccessorItem:TAccessorItem):Str255;
  265.         VAR
  266.             theCard: TCard;
  267.           aString : Str255; 
  268.             theClass: TItem;
  269.           
  270.         BEGIN
  271.             theCard:= TheAccessorItem.GetTheCard;
  272.             theClass:= theCard.GetTheClass;
  273.             aString:= GetAndEntabRsrcString(kImplSetAccessorID);
  274.             SELF.Replace(aString, '^0', theClass.GetTheItem);
  275.             SELF.Replace(aString, '^1', TheAccessorItem.GetTheItem);
  276.             SELF.Replace(aString, '^2', TheAccessorItem.GetFieldAccessed.GetItemType);
  277.             SELF.Replace(aString, '^3', TheAccessorItem.GetParameter);
  278.             IF TheAccessorItem.fFieldAccessed.GetPassByAddress THEN
  279.                 SELF.Replace(aString, '^4', '*')
  280.             ELSE
  281.                 SELF.Replace(aString, '^4', kEmptyString);
  282.             GetImplSetAccessorStr:=aString;
  283.         END;
  284.  
  285.     {$S ATextHandler}
  286.     FUNCTION TTextHandler.GetImplementationStr:Str255;
  287.           
  288.         BEGIN
  289.             GetImplementationStr:= GetAndEntabRsrcString(kImplementationID);
  290.         END;
  291.  
  292.     {$S ATextHandler}
  293.     FUNCTION TTextHandler.GetUnitEndStr:Str255;
  294.         VAR
  295.           aString : Str255; 
  296.           
  297.         BEGIN
  298.             GetUnitEndStr:= GetAndEntabRsrcString(kUnitEndStr);
  299.         END;
  300.         
  301.     {$S ATextHandler}
  302.     FUNCTION TTextHandler.GetImplementationNoteStr(TheCard:TCard):Str255;
  303.         VAR
  304.             aClassItem: TItem;
  305.              aString : Str255; 
  306.           
  307.         BEGIN
  308.             aClassItem:= TheCard.GetTheClass;
  309.             aString:= GetAndEntabRsrcString(kImplementationNoteID);
  310.             SELF.Replace(aString, '^0', aClassItem.GetTheItem);
  311.             GetImplementationNoteStr:=aString;
  312.         END;
  313.  
  314. FUNCTION TTextHandler.GetImplIncFileStr:Str255;
  315.         VAR
  316.           theTitle, aString : Str255; 
  317.           
  318.         BEGIN
  319.             theTitle:=fDesignDocument.GetUnitName;
  320.             aString:= GetAndEntabRsrcString(kImplIncFilesID);
  321.             SELF.Replace(aString, '^0', SELF.GetInterfaceFileName(theTitle));
  322.             GetImplIncFileStr:=aString;
  323.         END; {TTextHandler.GetImplIncFileStr}
  324.  
  325. {$S ATextHandler}
  326.     FUNCTION TTextHandler.GetGetAccessorImplementation(TheGetAccessorItem:TGetAccessorItem):Str255;
  327.     VAR
  328.             aString: str255;
  329.             theClass: TItem;
  330.             theClassName: str255;
  331.         BEGIN
  332.             theClass:= TheGetAccessorItem.GetTheCard.GetTheClass;
  333.             theClassName:= theClass.GetTheItem;
  334.             aString:= GetAndEntabRsrcString(kGetAccessorImplementationID);
  335.             SELF.Replace(aString, '^0', TheGetAccessorItem.GetTheImplDeclaration);
  336.             SELF.Replace(aString, '^1', TheGetAccessorItem.GetTheItem);
  337.             SELF.Replace(aString, '^2', TheGetAccessorItem.GetFieldAccessed.GetTheFieldStr);
  338.             GetGetAccessorImplementation:=aString;
  339.         END;
  340.  
  341.     {$S ATextHandler}
  342.     FUNCTION TTextHandler.GetSetAccessorImplementation(TheSetAccessorItem:TSetAccessorItem):Str255;
  343.     VAR
  344.         aString: str255;
  345.         theClass: TItem;
  346.             theClassName: str255;
  347.     BEGIN
  348.             theClass:= TheSetAccessorItem.GetTheCard.GetTheClass;
  349.             theClassName:= theClass.GetTheItem;
  350.             aString:= GetAndEntabRsrcString(kSetAccessorImplementationID);
  351.             SELF.Replace(aString, '^0', TheSetAccessorItem.GetTheImplDeclaration);
  352.             SELF.Replace(aString, '^1', TheSetAccessorItem.GetFieldAccessed.GetTheFieldStr);
  353.             SELF.Replace(aString, '^2', TheSetAccessorItem.GetParameter);
  354.             GetSetAccessorImplementation:=aString;
  355.         END;
  356.  
  357.     {$S ATextHandler}
  358.     FUNCTION TTextHandler.GetStdMethodImplementationStr(TheMethodItem:TMethodItem):Str255;
  359.         VAR
  360.           aString : Str255; 
  361.             theDeclaration: Str255;
  362.             theClass: TItem;
  363.             theClassName: str255;
  364.           
  365.     {$S ATextHandler}
  366.         BEGIN
  367.             theClass:= TheMethodItem.GetTheCard.GetTheClass;
  368.             theClassName:= theClass.GetTheItem;
  369.         aString:= SELF.GetAndEntabRsrcString(kStdMethodImplementationID);
  370.         theDeclaration:= TheMethodItem.GetTheImplDeclaration;
  371.         SELF.Replace(aString, '^0', theDeclaration);
  372.         GetStdMethodImplementationStr:=aString;
  373.         END;
  374.  
  375.     {$S ATextHandler}
  376.     FUNCTION TTextHandler.GetFieldsMethodDecStr(TheFieldsMethodItem:TFieldsMethodItem):Str255;
  377.         VAR
  378.           aString : Str255; 
  379.             theClass: TItem;
  380.             theClassName: str255;
  381.           
  382.         BEGIN
  383.             aString:= GetAndEntabRsrcString(kFieldsMethodDecStr);
  384.             theClass:= TheFieldsMethodItem.GetTheCard.GetTheClass;
  385.             theClassName:= theClass.GetTheItem;
  386.             SELF.Replace(aString, '^0', theClassName);
  387.             GetFieldsMethodDecStr:=aString;
  388.         END;
  389.  
  390.     {$S ATextHandler}
  391.     FUNCTION TTextHandler.GetImplFieldsMethodDecStr(TheFieldsMethodItem:TFieldsMethodItem):Str255;
  392.         VAR
  393.           aString : Str255; 
  394.             theClass: TItem;
  395.             theClassName: str255;
  396.           
  397.         BEGIN
  398.             aString:= GetAndEntabRsrcString(kImplFieldsMethodDecStr);
  399.             theClass:= TheFieldsMethodItem.GetTheCard.GetTheClass;
  400.             theClassName:= theClass.GetTheItem;
  401.             SELF.Replace(aString, '^0', theClassName);
  402.             GetImplFieldsMethodDecStr:=aString;
  403.         END;
  404.  
  405.     {$S ATextHandler}
  406.     FUNCTION TTextHandler.GetFieldsMethodImpStr1:Str255;
  407.         BEGIN
  408.             GetFieldsMethodImpStr1:=GetAndEntabRsrcString(kFieldsMethodImpStr1);
  409.         END;
  410.  
  411.     {$S ATextHandler}
  412.     FUNCTION TTextHandler.GetFieldsMethodImpStr2(TheFieldsMethodItem:TFieldsMethodItem):Str255;
  413.         VAR
  414.             aString, theDeclaration: str255;
  415.             theClass: TItem;
  416.             theClassName: str255;
  417.           
  418.         BEGIN
  419.             theClass:= TheFieldsMethodItem.GetTheCard.GetTheClass;
  420.             theClassName:= theClass.GetTheItem;
  421.             aString:= GetAndEntabRsrcString(kFieldsMethodImpStr2);
  422.             SELF.Replace(aString, '^1', theClassName);
  423.             GetFieldsMethodImpStr2:=aString;
  424.         END;
  425.  
  426.     {$S ATextHandler}
  427.     FUNCTION TTextHandler.GetFieldsMethodImpStr3:Str255;
  428.           
  429.         BEGIN
  430.             GetFieldsMethodImpStr3:= GetAndEntabRsrcString(kFieldsMethodImpStr3);
  431.         END;
  432.  
  433.     {$S ATextHandler}
  434.     FUNCTION TTextHandler.GetFieldsMethodCodeLineStr(theFieldItem: TFieldItem):Str255;
  435.         VAR
  436.           aString : Str255; 
  437.           
  438.         BEGIN
  439.             aString:= GetAndEntabRsrcString(kFieldsMethodCodeLineStr);
  440.             SELF.Replace(aString, '^0', theFieldItem.GetTheFieldStr);
  441.             SELF.Replace(aString, '^1', theFieldItem.GetTheFieldsTypeConst);
  442.             GetFieldsMethodCodeLineStr:=aString;
  443.         END;
  444.  
  445.     {$S ATextHandler}
  446.     FUNCTION TTextHandler.GetTheTypeName(index:ArrayIndex): Str63;
  447.     VAR
  448.         TheTypeTableElement : TTypeTableElement;
  449.         
  450.     BEGIN
  451.         fTypeTable.GetElementsAt(index,@TheTypeTableElement,1);
  452.         GetTheTypeName:= TheTypeTableElement.TypeName[SELF.GetLanguage];
  453.     END;
  454.     
  455. {$S ATextHandler}
  456.     FUNCTION TTextHandler.ReturnFieldsTypeConst(theFieldItem: TFieldItem): str255;
  457.  
  458.     VAR
  459.         count:    ArrayIndex;
  460.         aString,theTypeStr: str255;
  461.         TheTypeTableElement : TTypeTableElement;
  462.  
  463.     BEGIN
  464.         theTypeStr:= theFieldItem.GetItemType;
  465.         aString:= 'bTitle';
  466.         FOR count:=1 to fNumberOfElements DO
  467.             IF SELF.GetTheTypeName(count) = theTypeStr THEN
  468.                 BEGIN
  469.                     fTypeTable.GetElementsAt(count,@TheTypeTableElement,1);
  470.                     aString:=TheTypeTableElement.FieldsTypeConst;
  471.                 END;
  472.             ReturnFieldsTypeConst:= aString; 
  473.     END;    {TTextHandler.ReturnFieldsTypeConst}
  474.  
  475.  
  476. {$S ATextHandler}
  477.     FUNCTION TTextHandler.ReturnByAddress(theFieldItem: TFieldItem): BOOLEAN;
  478.  
  479.     VAR
  480.         count:    ArrayIndex;
  481.         theTypeStr: str255;
  482.         byAddress: BOOLEAN;
  483.         TheTypeTableElement : TTypeTableElement;
  484.  
  485.     BEGIN
  486.         theTypeStr:= theFieldItem.GetItemType;
  487.         byAddress:= TRUE;
  488.         FOR count:=1 to fNumberOfElements DO
  489.             IF SELF.GetTheTypeName(count) = theTypeStr THEN
  490.                 BEGIN
  491.                     fTypeTable.GetElementsAt(count,@TheTypeTableElement,1);
  492.                     byAddress:=TheTypeTableElement.byAddress;
  493.                 END;
  494.             ReturnByAddress:= byAddress; 
  495.     END;    {TTextHandler.ReturnByAddress}
  496.  
  497.     {$S ATextHandler}
  498.     FUNCTION TTextHandler.GetIncludeStatement:Str255;
  499.         VAR
  500.           theTitle, aString : Str255; 
  501.           
  502.         BEGIN
  503.             theTitle:=fDesignDocument.GetUnitName;
  504.             aString:= GetAndEntabRsrcString(kIncludeStatementID);
  505.             SELF.Replace(aString, '^0', SELF.GetImplementationFileName(theTitle));
  506.             GetIncludeStatement:=aString;
  507.         END; {TTextHandler.GetIncludeStatement}
  508.  
  509.     {$S ATextHandler}
  510.     FUNCTION TTextHandler.GetFieldItemDeclaration(theFieldItem:TFieldItem):Str255;
  511.         VAR
  512.           aString : Str255; 
  513.  
  514.     BEGIN
  515.         aString:=GetAndEntabRsrcString(kFieldItemDeclarationStrID);
  516.         SELF.Replace(aString, '^0', theFieldItem.GetTheItem);
  517.         SELF.Replace(aString, '^1', theFieldItem.GetItemType);
  518.         IF theFieldItem.GetPassByAddress THEN
  519.             SELF.Replace(aString, '^4', '*')
  520.         ELSE
  521.             SELF.Replace(aString, '^4', kEmptyString);
  522.         GetFieldItemDeclaration:= aString;
  523.     END;    {TTextHandler.GetFieldItemDeclaration}
  524.  
  525.     {$S ATextHandler}
  526.     FUNCTION TTextHandler.GetFieldItemImplDeclaration(theFieldItem:TFieldItem):Str255;
  527.         VAR
  528.           aString : Str255; 
  529.  
  530.     BEGIN
  531.         aString:=GetAndEntabRsrcString(kFieldItemImplDeclarationStrID);
  532.         SELF.Replace(aString, '^0', theFieldItem.GetTheItem);
  533.         SELF.Replace(aString, '^1', theFieldItem.GetItemType);
  534.         IF theFieldItem.GetPassByAddress THEN
  535.             SELF.Replace(aString, '^4', '*')
  536.         ELSE
  537.             SELF.Replace(aString, '^4', kEmptyString);
  538.         GetFieldItemImplDeclaration:= aString;
  539.     END;    {TTextHandler.GetFieldItemImplDeclaration}
  540.  
  541.     {$S ATextHandler}
  542.     FUNCTION TTextHandler.GetCollaboratorDeclaration
  543.                     (theCollaboratorItem:TCollaboratorItem):Str255;
  544.  
  545.     VAR
  546.         theDeclarationStr: str255;
  547.  
  548.     BEGIN
  549.         theDeclarationStr:=GetAndEntabRsrcString(kCollaboratordeclarationStrID);
  550.         SELF.Replace(theDeclarationStr, '^0', theCollaboratorItem.GetTheFieldStr);
  551.         SELF.Replace(theDeclarationStr, '^1', theCollaboratorItem.GetItemType);
  552.         GetCollaboratorDeclaration:= theDeclarationStr;
  553.     END;    {TTextHandler.GetCollaboratorDeclaration}
  554.  
  555.     {$S ATextHandler}
  556.     FUNCTION TTextHandler.GetImplCollaboratorDeclaration
  557.                     (theCollaboratorItem:TCollaboratorItem):Str255;
  558.  
  559.     VAR
  560.         theDeclarationStr: str255;
  561.  
  562.     BEGIN
  563.         theDeclarationStr:=GetAndEntabRsrcString(kImplCollaboratorDeclarationStrID);
  564.         SELF.Replace(theDeclarationStr, '^0', theCollaboratorItem.GetTheFieldStr);
  565.         SELF.Replace(theDeclarationStr, '^1', theCollaboratorItem.GetItemType);
  566.         GetImplCollaboratorDeclaration:= theDeclarationStr;
  567.     END;    {TTextHandler.GetImplCollaboratorDeclaration}
  568.  
  569.     {$S ATextHandler}
  570.     FUNCTION TTextHandler.GetInterfaceFileName(theName: str255):Str255;
  571.  
  572.     VAR
  573.         aString: str255;
  574.  
  575.     BEGIN
  576.         SELF.CheckFileName(theName);
  577.         aString:=GetAndEntabRsrcString(kInterfaceFileNameID);
  578.         SELF.Replace(aString, '^0', theName);
  579.         GetInterfaceFileName:= aString;
  580.     END;    {TTextHandler.GetInterfaceFileName}
  581.  
  582.     {$S ATextHandler}
  583.     FUNCTION TTextHandler.GetImplementationFileName(theName: str255):Str255;
  584.  
  585.     VAR
  586.         aString: str255;
  587.  
  588.     BEGIN
  589.         SELF.CheckFileName(theName);
  590.         aString:=GetAndEntabRsrcString(kImplementationFileNameID);
  591.         SELF.Replace(aString, '^0', theName);
  592.         GetImplementationFileName:= aString;
  593.     END;    {TTextHandler.GetImplementationFileName}
  594.  
  595. {typeTable methods}
  596.     {$S ATextHandler}
  597. PROCEDURE TTextHandler.ReadInTypeTable;
  598. CONST
  599.     kStartingTableSize = 50;
  600.     
  601. VAR        
  602.     index: Integer;
  603.     DAIndex: ArrayIndex;
  604.     TheNewElement: TTypeTableElement;
  605.     TheNewTypeTable: TDynamicArray;
  606.     aString : Str255;
  607.  
  608.     FUNCTION GetFieldsTypeConst(Element: Integer): Str63;
  609.     VAR 
  610.         aString: Str255;
  611.     
  612.     BEGIN
  613.         GetIndString(aString,kTypeTableID,(Element*kTypeTableWidth) + kFieldsTypeOffset);
  614.         GetFieldsTypeConst:= Concat(aString);
  615.     END;
  616.     
  617.     FUNCTION GetByAddress(Element: Integer): Boolean;
  618.     VAR 
  619.         aString: Str255;
  620.     
  621.     BEGIN
  622.         GetIndString(aString,kTypeTableID,(Element*kTypeTableWidth) + kByAddressOffset);
  623.         GetByAddress:= (aString <> 'n');
  624.     END;
  625.     
  626. BEGIN
  627.     NEW(TheNewTypeTable);
  628.     FailNIL(TheNewTypeTable);
  629.     fTypeTable:=TheNewTypeTable;
  630.     fTypeTable.IDynamicArray(kStartingTableSize,SizeOf(TTypeTableElement));
  631.     fnumberOfElements:=0;
  632.     GetIndString(aString,kTypeTableID,1);
  633.     WHILE aString<>kEmptyString DO
  634.         BEGIN
  635.             WITH TheNewElement DO
  636.                 BEGIN
  637.                     TypeName[1]:=Concat(aString);
  638.                     FOR index:=2 to kNumberOfLanguages DO
  639.                         BEGIN
  640.                             GetIndString(aString,kTypeTableID,(fnumberOfElements*kTypeTableWidth) + index);
  641.                             TypeName[index]:=Concat(aString);
  642.                         END;
  643.                     FieldsTypeConst:=GetFieldsTypeConst(fnumberOfElements);
  644.                     byAddress:=GetByAddress(fnumberOfElements);
  645.                     fnumberOfElements:=fnumberOfElements+1;
  646.                     GetIndString(aString,kTypeTableID,(fnumberOfElements*kTypeTableWidth)+1);
  647.                 END;
  648.                 fTypeTable.InsertElementsBefore(1, @TheNewElement, 1);
  649.         END;
  650. END; {TTextHandler.ReadInTypeTable}
  651.  
  652.  
  653. {$S ATextHandler}
  654. PROCEDURE TTextHandler.SetItemTypeMenu(thePopupMenu : TPopup);
  655. CONST
  656.     kMenuID = 999;
  657.     
  658. VAR 
  659.     TheLanguage : Integer;  {this tells us whether we are reading pascal or c++}
  660.     RecordNumber : Integer;
  661.     aString : Str255;
  662.     theNewMenu :  MenuHandle;
  663.     
  664.     FUNCTION TheItemNumber:INTEGER;
  665.     BEGIN
  666.         TheItemNumber:=(RecordNumber*kTypeTableWidth)+TheLanguage;
  667.     END;
  668.     
  669. BEGIN
  670.     TheLanguage:=SELF.GetLanguage;
  671.     RecordNumber:=0;
  672.     theNewMenu:=NewMenu(kMenuID,'Type: ');
  673.     FailNILResource(theNewMenu);
  674.     
  675.     GetIndString(aString, kTypeTableID, TheItemNumber);    
  676.     WHILE aString <> kEmptyString DO
  677.         BEGIN
  678.             AppendMenu(theNewMenu,aString);
  679.             RecordNumber:=RecordNumber+1;
  680.             GetIndString(aString, kTypeTableID, TheItemNumber);    
  681.             {writeln(aString);}
  682.         END; 
  683.     ThePopupMenu.SetPopup(theNewMenu, kNoResource, 1, kReDraw);
  684. END; {TTextHandler.SetItemTypeMenu}
  685.  
  686.  
  687. {$S ATextHandler}
  688. PROCEDURE TTextHandler.SetSuperClassTypeMenu(thePopupMenu : TPopup);
  689. CONST
  690.     kMenuID = 998;
  691.     
  692. VAR 
  693.     TheLanguage : Integer;  {this tells us whether we are reading pascal or c++}
  694.     RecordNumber : Integer;
  695.     aString : Str255;
  696.     theNewMenu :  MenuHandle;
  697.     theCardList: TList;
  698.     
  699.     PROCEDURE AddCardToMenu(aCard: TCard);
  700.     VAR
  701.         aString: Str255;
  702.         
  703.     BEGIN
  704.         aString:= aCard.GetTheClass.GetTheName;
  705.         InsMenuItem(theNewMenu,aString,RecordNumber);
  706.         RecordNumber:=RecordNumber+1;
  707.     END;
  708.     
  709. BEGIN
  710.     {writeln('In SetSuperClassTypeMenu');}
  711.     RecordNumber:=1;
  712.     theNewMenu:=NewMenu(kMenuID,'');
  713.     FailNILResource(theNewMenu);
  714.     
  715.     GetIndString(aString, kObjectMenuID, RecordNumber);    
  716.     WHILE aString <> kEmptyString DO
  717.         BEGIN
  718.             AppendMenu(theNewMenu,aString);
  719.             RecordNumber:=RecordNumber+1;
  720.             GetIndString(aString, kObjectMenuID, RecordNumber);
  721.             {writeln(aString);}
  722.         END; 
  723.  
  724.             {Insert two blank lines}
  725.     InsMenuItem(theNewMenu,CONCAT('(',kBlankLine,';(',kBlankLine),1);
  726.  
  727.             {now insert the names of all the cards between the blank lines}
  728.     RecordNumber:=2;    
  729.     theCardList:= SELF.GetDesignDocument.GetCardList;
  730.     theCardList.Each(AddCardToMenu);    
  731.  
  732.             {and set the menu}
  733.     ThePopupMenu.SetPopup(theNewMenu, kNoResource, 1, kReDraw);
  734. {    writeln('Out SetSuperClassTypeMenu');}
  735. END; {TTextHandler.SetSuperClassTypeMenu}
  736.  
  737. {$S ATextHandler}
  738. PROCEDURE TTextHandler.SetCollaboratorsMenu(thePopupMenu : TPopup);
  739. BEGIN
  740.     SELF.SetSuperClassTypeMenu(thePopupMenu);
  741. END; {TTextHandler.SetCollaboratorsMenu}
  742.  
  743. {$S ATextHandler}
  744. PROCEDURE TTextHandler.ChangeLanguageTo(TheNewLanguage:Integer);
  745.  
  746. VAR
  747.     TheDesignDocument : TDesignDocument;
  748.     TheOldLanguage : Integer;
  749.     
  750.     PROCEDURE TranslateTheCards(TheCard : TCard);
  751.     VAR
  752.         TheFieldList : TMyList;
  753.         BEGIN
  754.             TheCard.TranslateTheCard(TheOldLanguage, TheNewLanguage);
  755.         END; {TranslateTheItems}
  756.     
  757. BEGIN
  758.     TheOldLanguage:=SELF.GetLanguage;
  759.     TheDesignDocument:=SELF.fDesignDocument;
  760.     SELF.SetLanguage(TheNewLanguage);
  761.     TheDesignDocument.GetCardList.EACH(TranslateTheCards);
  762. END; {TTextHandler.ChangeLanguageTo}
  763.  
  764. {$S ATextHandler}
  765. FUNCTION TTextHandler.FindTypeTableEntry(TheLanguage : Integer; TheItem: TFieldItem):ArrayIndex;
  766. VAR
  767.     index,wherefound : ArrayIndex;
  768.     TheItemType : Str255;
  769.     TheArrayElement: TTypeTableElement;
  770.     
  771. BEGIN
  772.     TheItemType:=TheItem.GetItemType;
  773.     whereFound := kTableEntryNotFound;
  774.     index:=1;
  775.     WHILE (whereFound= kTableEntryNotFound) AND (index<=fNumberOfElements) DO
  776.       BEGIN
  777.             fTypeTable.GetElementsAt(index,@TheArrayElement,1);
  778.             IF TheArrayElement.TypeName[TheLanguage]=TheItemType THEN
  779.                 IF TheArrayElement.byAddress = TheItem.fPassByAddress THEN
  780.                     whereFound:=index;
  781.             index:= index + 1;
  782.         END;
  783.     FindTypeTableEntry:=whereFound;
  784. END;    {TTextHandler.FindTypeTableEntry}
  785.  
  786. {$S ATextHandler}
  787. PROCEDURE TTextHandler.TranslateTheItem(TheOldLanguage, TheNewLanguage: Integer;
  788.                                                                             TheItem: TFieldItem);
  789.  
  790. VAR 
  791.     TheItemType : Str255;
  792.     whereFound : ArrayIndex;
  793.     TheArrayElement: TTypeTableElement;
  794.     
  795. BEGIN
  796.     TheItemType:=TheItem.GetItemType;
  797.     whereFound := FindTypeTableEntry(TheNewLanguage, TheItem);
  798.     IF whereFound = kTableEntryNotFound THEN
  799.         BEGIN
  800.             whereFound := FindTypeTableEntry(TheOldLanguage, TheItem);
  801.             IF whereFound <> kTableEntryNotFound THEN
  802.               BEGIN
  803.                     fTypeTable.GetElementsAt(whereFound,@TheArrayElement,1);
  804.                     TheItem.SetItemType(TheArrayElement.TypeName[TheNewLanguage]);
  805.                 END;
  806.         END;
  807. END;
  808.  
  809. {$S ATextHandler}
  810. PROCEDURE TTextHandler.CheckFileName(VAR theName: str255);
  811.  
  812.     VAR
  813.         index: 0..255;
  814.         legalChars: SET OF CHAR;
  815.         done: boolean;
  816.  
  817.     BEGIN
  818.         legalChars:= ['a'..'z', 'A'..'Z', '0'..'9', '_'];
  819.         index:= 1;
  820.         WHILE index < Length(theName) DO
  821.             BEGIN
  822.                 done:= false;
  823.                 WHILE (NOT (theName[index] IN legalChars)) AND (NOT done) DO
  824.                     IF Length(theName) < index THEN
  825.                         done:= true
  826.                     ELSE
  827.                         Delete(theName, index, 1);
  828.                 index:= index + 1;
  829.             END;
  830.     END;    {TTextHandler.CheckFileName}
  831.  
  832.     {$S ATextHandler}
  833.     FUNCTION TTextHandler.GetInlineSetAccessorStr(TheSetAccessorItem:TSetAccessorItem):Str255;
  834.         VAR
  835.             theCard: TCard;
  836.           aString : Str255; 
  837.             theClass: TItem;
  838.           
  839.         BEGIN
  840.             theCard:= TheSetAccessorItem.GetTheCard;
  841.             theClass:= theCard.GetTheClass;
  842.             aString:= GetAndEntabRsrcString(kInlineSetAccessorID);
  843.             SELF.Replace(aString, '^0', theClass.GetTheItem);
  844.             SELF.Replace(aString, '^1', TheSetAccessorItem.GetTheItem);
  845.             SELF.Replace(aString, '^2', TheSetAccessorItem.GetFieldAccessed.GetItemType);
  846.             SELF.Replace(aString, '^3', TheSetAccessorItem.GetParameter);
  847.             IF TheSetAccessorItem.fFieldAccessed.GetPassByAddress THEN
  848.                 SELF.Replace(aString, '^4', '*')
  849.             ELSE
  850.                 SELF.Replace(aString, '^4', kEmptyString);
  851.             SELF.Replace(aString, '^5', TheSetAccessorItem.GetFieldAccessed.GetTheFieldStr);
  852.             GetInlineSetAccessorStr:=aString;
  853.         END;
  854.  
  855.     {$S ATextHandler}
  856.     FUNCTION TTextHandler.GetInlineGetAccessorStr(TheGetAccessorItem:TGetAccessorItem):Str255;
  857.         VAR
  858.             theCard: TCard;
  859.           aString : Str255; 
  860.             theClass: TItem;
  861.           
  862.         BEGIN
  863.             theCard:= TheGetAccessorItem.GetTheCard;
  864.             theClass:= theCard.GetTheClass;
  865.             aString:= GetAndEntabRsrcString(kInlineGetAccessorID);
  866.             SELF.Replace(aString, '^0', theClass.GetTheItem);
  867.             SELF.Replace(aString, '^1', TheGetAccessorItem.GetTheItem);
  868.             SELF.Replace(aString, '^2', TheGetAccessorItem.GetFieldAccessed.GetItemType);
  869.             SELF.Replace(aString, '^5', TheGetAccessorItem.GetFieldAccessed.GetTheFieldStr);
  870.             IF TheGetAccessorItem.fFieldAccessed.GetPassByAddress THEN
  871.                 SELF.Replace(aString, '^4', '*')
  872.             ELSE
  873.                 SELF.Replace(aString, '^4', kEmptyString);
  874.             GetInlineGetAccessorStr:=aString;
  875.         END;
  876.  
  877.     {$S ATextHandler}
  878.     FUNCTION TTextHandler.GetFwdClassDeclStr(TheCard:TCard):Str255;
  879.         VAR
  880.           aString : Str255; 
  881.             theClass: TItem;
  882.           
  883.         BEGIN
  884.             theClass:= TheCard.GetTheClass;
  885.             aString:= GetAndEntabRsrcString(kFwdClassDeclID);
  886.             SELF.Replace(aString, '^0', theClass.GetTheItem);
  887.             GetFwdClassDeclStr:=aString;
  888.         END;
  889.  
  890. {$S AClose}
  891. PROCEDURE TTextHandler.Free;  OVERRIDE;
  892. BEGIN
  893.     fTypeTable.Free;
  894.     INHERITED Free;
  895. END; {TTextHandler.Free}
  896.  
  897. {$S AFields}
  898. PROCEDURE TTextHandler.Fields(PROCEDURE DoToField(
  899.         fieldName: Str255; fieldAddr: Ptr; fieldType: INTEGER)); OVERRIDE;
  900.         
  901.     BEGIN
  902.         DoToField('TTextHandler', NIL, bClass);
  903.         DoToField('fDesignDocument', @fDesignDocument, bObject);
  904.         DoToField('fTypeTable', @fTypeTable, bObject);
  905.         DoToField('fLanguage', @fLanguage, bINTEGER);
  906.         INHERITED Fields(DoToField);
  907.     END;
  908.  
  909.